//浅拷贝
var a1={b:{c:{}}};
var a2=shallowClone(a1);
var a3=deepClone(a1);
function shallowClone(source) {
    var target={};
    for(var i in source){
        if(source.hasOwnProperty(i)){
            target[i]=source[i]
        }
    }
    return target
}
//1.我们怎么去实现深拷贝呢，这里可以递归递归去复制所有层级属性。
function deepClone(obj){
    let objClone = Array.isArray(obj)?[]:{};
    if(obj && typeof obj==="object"){
        for(key in obj){
            if(obj.hasOwnProperty(key)){
                //判断ojb子元素是否为对象，如果是，递归复制
                if(obj[key]&&typeof obj[key] ==="object"){
                    objClone[key] = deepClone(obj[key]);
                }else{
                    //如果不是，简单复制
                    objClone[key] = obj[key];
                }
            }
        }
    }
    return objClone;
}
/*let a=[1,2,3,4],
    b=deepClone(a);
a[0]=2;
console.log(a,b);*/

let a=[0,1,[2,3],4],
    // b=a.slice();
    b=[].concat(a);
a[0]=1;
a[2][0]=1;
// console.log(a,b);
//2.除了递归，我们还可以借用JSON对象的parse和stringify
function cloneJSON(source) {
    return JSON.parse(JSON.stringify(source));
}
function createData(deep, breadth) {
    var data = {};
    var temp = data;

    for (var i = 0; i < deep; i++) {
        temp['data'] = {};

        temp = temp['data'];
        for (var j = 0; j < breadth; j++) {
            temp[j] = j;
        }
    }
    return data;
}

// createData(1, 3); // 1层深度，每层有3个数据 {data: {0: 0, 1: 1, 2: 2}}
createData(3, 0); // 3层深度，每层有0个数据 {data: {data: {data: {}}}}

function cloneLoop(x) {
    const root = {};

    // 栈
    const loopList = [
        {
            parent: root,
            key: undefined,
            data: x,
        }
    ];

    while(loopList.length) {
        // 深度优先
        const node = loopList.pop();
        const parent = node.parent;
        const key = node.key;
        const data = node.data;

        // 初始化赋值目标，key为undefined则拷贝到父元素，否则拷贝到子元素
        let res = parent;
        if (typeof key !== 'undefined') {
            res = parent[key] = {};
        }

        for(let k in data) {
            if (data.hasOwnProperty(k)) {
                if (typeof data[k] === 'object') {
                    // 下一次循环
                    loopList.push({
                        parent: res,
                        key: k,
                        data: data[k],
                    });
                } else {
                    res[k] = data[k];
                }
            }
        }
    }

    return root;
}
//执行上下文时，首先会处理函数声明，其次会处理变量声明，如果变量名称跟已经声明的形式参数或函数不同，则变量声明不会干扰已经存在的这类属性

/*
var str= "documet-get-by-id";
var str1=str.replace("(?<=-)+\\w{1}", function(word){
    console.log(word)
    return word.toUpperCase();}
);
    console.log(str1)*/
var str="documet-get-by-id";
var arr=str.replace(/(?<=-)[a-z]{1}/g,function(word){
    console.log(word)
    return word.substring(1).toUpperCase();});
console.log(arr)

